package com.rolerealm.controller;

import com.rolerealm.common.result.Result;
import com.rolerealm.common.util.ResultUtil;
import com.rolerealm.domain.dto.CharacterCreateDTO;
import com.rolerealm.domain.dto.CharacterSearchDTO;
import com.rolerealm.domain.dto.CharacterUpdateDTO;
import com.rolerealm.domain.vo.CharacterDetailVO;
import com.rolerealm.domain.vo.CharacterVO;
import com.rolerealm.domain.vo.PageResult;
import com.rolerealm.domain.vo.PresetInitResult;
import com.rolerealm.service.CharacterService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;

import jakarta.validation.Valid;
import java.util.List;

/**
 * 角色管理控制器
 * 
 * @author RoleRealm Team
 * @version 1.0.0
 */
@Slf4j
@RestController
@RequestMapping("/api/characters")
@RequiredArgsConstructor
public class CharacterController {

    private final CharacterService characterService;

    /**
     * 分页查询角色列表
     * 
     * @param name 名称模糊匹配
     * @param category 类别筛选
     * @param era 时代筛选
     * @param region 地区筛选
     * @param language 语言筛选
     * @param skillType 技能类型筛选
     * @param page 页码，默认1
     * @param size 每页大小，默认10
     * @return 角色分页列表
     */
    @GetMapping
    public Result<PageResult<CharacterVO>> getCharacters(
            @RequestParam(required = false) String name,
            @RequestParam(required = false) String category,
            @RequestParam(required = false) String era,
            @RequestParam(required = false) String region,
            @RequestParam(required = false) String language,
            @RequestParam(required = false) String skillType,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        
        log.debug("查询角色列表，参数：name={}, category={}, era={}, region={}, language={}, skillType={}, page={}, size={}", 
                name, category, era, region, language, skillType, page, size);
        
        CharacterSearchDTO searchDTO = CharacterSearchDTO.builder()
                .name(name)
                .category(category)
                .era(era)
                .region(region)
                .language(language)
                .skillType(skillType)
                .page(page)
                .size(size)
                .build();
        
        PageResult<CharacterVO> result = characterService.getCharacters(searchDTO);
        return ResultUtil.success(result);
    }

    /**
     * 根据角色ID获取角色详情
     * 
     * @param id 角色ID
     * @return 角色详情
     */
    @GetMapping("/{id}")
    public Result<CharacterDetailVO> getCharacterDetail(@PathVariable Long id) {
        log.debug("查询角色详情，角色ID：{}", id);
        
        CharacterDetailVO character = characterService.getCharacterDetail(id);
        return ResultUtil.success(character);
    }

    /**
     * 全文搜索角色
     * 
     * @param q 搜索关键词
     * @param category 类别筛选
     * @param era 时代筛选
     * @param region 地区筛选
     * @param language 语言筛选
     * @param skillType 技能类型筛选
     * @param page 页码，默认1
     * @param size 每页大小，默认10
     * @return 角色分页列表
     */
    @GetMapping("/search")
    public Result<PageResult<CharacterVO>> searchCharacters(
            @RequestParam String q,
            @RequestParam(required = false) String category,
            @RequestParam(required = false) String era,
            @RequestParam(required = false) String region,
            @RequestParam(required = false) String language,
            @RequestParam(required = false) String skillType,
            @RequestParam(defaultValue = "1") Integer page,
            @RequestParam(defaultValue = "10") Integer size) {
        
        log.debug("搜索角色，关键词：{}，参数：category={}, era={}, region={}, language={}, skillType={}, page={}, size={}", 
                q, category, era, region, language, skillType, page, size);
        
        CharacterSearchDTO searchDTO = CharacterSearchDTO.builder()
                .keyword(q)
                .category(category)
                .era(era)
                .region(region)
                .language(language)
                .skillType(skillType)
                .page(page)
                .size(size)
                .build();
        
        PageResult<CharacterVO> result = characterService.searchCharacters(searchDTO);
        return ResultUtil.success(result);
    }

    /**
     * 获取热门角色
     * 
     * @param limit 限制数量，默认10
     * @return 角色列表
     */
    @GetMapping("/popular")
    public Result<List<CharacterVO>> getPopularCharacters(
            @RequestParam(defaultValue = "10") Integer limit) {
        
        log.debug("查询热门角色，限制数量：{}", limit);
        
        List<CharacterVO> characters = characterService.getPopularCharacters(limit);
        return ResultUtil.success(characters);
    }

    /**
     * 根据技能类型获取角色
     * 
     * @param skillType 技能类型
     * @param limit 限制数量，默认10
     * @return 角色列表
     */
    @GetMapping("/skill/{skillType}")
    public Result<List<CharacterVO>> getCharactersBySkillType(
            @PathVariable String skillType,
            @RequestParam(defaultValue = "10") Integer limit) {
        
        log.debug("根据技能类型查询角色，技能类型：{}，限制数量：{}", skillType, limit);
        
        List<CharacterVO> characters = characterService.getCharactersBySkillType(skillType, limit);
        return ResultUtil.success(characters);
    }

    /**
     * 初始化预设角色库（管理接口）
     * 
     * @return 初始化结果
     */
    @PostMapping("/presets:init")
    public Result<PresetInitResult> initPresetCharacters() {
        log.info("开始初始化预设角色库");
        
        PresetInitResult result = characterService.initPresetCharacters();
        return ResultUtil.success(result);
    }

    /**
     * 创建角色（管理接口）
     * 
     * @param createDTO 角色创建请求
     * @return 创建的角色信息
     */
    @PostMapping
    public Result<CharacterVO> createCharacter(@Valid @RequestBody CharacterCreateDTO createDTO) {
        log.info("创建角色，角色名称：{}", createDTO.getName());
        
        CharacterVO character = characterService.createCharacter(createDTO);
        return ResultUtil.success(character);
    }

    /**
     * 更新角色（管理接口）
     * 
     * @param updateDTO 角色更新请求
     * @return 更新后的角色信息
     */
    @PutMapping
    public Result<CharacterVO> updateCharacter(@Valid @RequestBody CharacterUpdateDTO updateDTO) {
        log.info("更新角色，角色ID：{}", updateDTO.getId());
        
        CharacterVO character = characterService.updateCharacter(updateDTO);
        return ResultUtil.success(character);
    }

    /**
     * 删除角色（管理接口）
     * 
     * @param characterId 角色ID
     * @return 操作结果
     */
    @DeleteMapping("/{characterId}")
    public Result<Boolean> deleteCharacter(@PathVariable Long characterId) {
        log.info("删除角色，角色ID：{}", characterId);
        
        Boolean result = characterService.deleteCharacter(characterId);
        return ResultUtil.success(result);
    }

    /**
     * 批量删除角色（管理接口）
     * 
     * @param characterIds 角色ID列表
     * @return 删除成功的数量
     */
    @DeleteMapping("/batch")
    public Result<Integer> batchDeleteCharacters(@RequestBody List<Long> characterIds) {
        log.info("批量删除角色，角色ID列表：{}", characterIds);
        
        Integer count = characterService.batchDeleteCharacters(characterIds);
        return ResultUtil.success(count);
    }

    /**
     * 更新角色状态（管理接口）
     * 
     * @param characterId 角色ID
     * @param status 状态
     * @return 操作结果
     */
    @PutMapping("/{characterId}/status")
    public Result<Boolean> updateCharacterStatus(@PathVariable Long characterId, @RequestParam Integer status) {
        log.info("更新角色状态，角色ID：{}，状态：{}", characterId, status);
        
        Boolean result = characterService.updateCharacterStatus(characterId, status);
        return ResultUtil.success(result);
    }
}
